home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 SRC / Mac / Modules / cm / Cmmodule.c < prev    next >
Text File  |  1996-04-12  |  20KB  |  771 lines
  1.  
  2. /* =========================== Module Cm ============================ */
  3.  
  4. #include "Python.h"
  5.  
  6.  
  7.  
  8. #define SystemSevenOrLater 1
  9.  
  10. #include "macglue.h"
  11. #include <Memory.h>
  12. #include <Dialogs.h>
  13. #include <Menus.h>
  14. #include <Controls.h>
  15.  
  16. extern PyObject *ResObj_New(Handle);
  17. extern int ResObj_Convert(PyObject *, Handle *);
  18. extern PyObject *OptResObj_New(Handle);
  19. extern int OptResObj_Convert(PyObject *, Handle *);
  20.  
  21. extern PyObject *WinObj_New(WindowPtr);
  22. extern int WinObj_Convert(PyObject *, WindowPtr *);
  23. extern PyTypeObject Window_Type;
  24. #define WinObj_Check(x) ((x)->ob_type == &Window_Type)
  25.  
  26. extern PyObject *DlgObj_New(DialogPtr);
  27. extern int DlgObj_Convert(PyObject *, DialogPtr *);
  28. extern PyTypeObject Dialog_Type;
  29. #define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
  30.  
  31. extern PyObject *MenuObj_New(MenuHandle);
  32. extern int MenuObj_Convert(PyObject *, MenuHandle *);
  33.  
  34. extern PyObject *CtlObj_New(ControlHandle);
  35. extern int CtlObj_Convert(PyObject *, ControlHandle *);
  36.  
  37. extern PyObject *GrafObj_New(GrafPtr);
  38. extern int GrafObj_Convert(PyObject *, GrafPtr *);
  39.  
  40. extern PyObject *BMObj_New(BitMapPtr);
  41. extern int BMObj_Convert(PyObject *, BitMapPtr *);
  42.  
  43. extern PyObject *PMObj_New(PixMapHandle);
  44. extern int PMObj_Convert(PyObject *, PixMapHandle *);
  45.  
  46. extern PyObject *WinObj_WhichWindow(WindowPtr);
  47.  
  48. #include <Components.h>
  49.  
  50. /*
  51. ** Parse/generate ComponentDescriptor records
  52. */
  53. PyObject *CmpDesc_New(itself)
  54.     ComponentDescription *itself;
  55. {
  56.  
  57.     return Py_BuildValue("O&O&O&ll", 
  58.         PyMac_BuildOSType, itself->componentType,
  59.         PyMac_BuildOSType, itself->componentSubType,
  60.         PyMac_BuildOSType, itself->componentManufacturer,
  61.         itself->componentFlags, itself->componentFlagsMask);
  62. }
  63.  
  64. CmpDesc_Convert(v, p_itself)
  65.     PyObject *v;
  66.     ComponentDescription *p_itself;
  67. {
  68.     return PyArg_ParseTuple(v, "O&O&O&ll",
  69.         PyMac_GetOSType, &p_itself->componentType,
  70.         PyMac_GetOSType, &p_itself->componentSubType,
  71.         PyMac_GetOSType, &p_itself->componentManufacturer,
  72.         &p_itself->componentFlags, &p_itself->componentFlagsMask);
  73. }
  74.  
  75.  
  76. static PyObject *Cm_Error;
  77.  
  78. /* ----------------- Object type ComponentInstance ------------------ */
  79.  
  80. PyTypeObject ComponentInstance_Type;
  81.  
  82. #define CmpInstObj_Check(x) ((x)->ob_type == &ComponentInstance_Type)
  83.  
  84. typedef struct ComponentInstanceObject {
  85.     PyObject_HEAD
  86.     ComponentInstance ob_itself;
  87. } ComponentInstanceObject;
  88.  
  89. PyObject *CmpInstObj_New(itself)
  90.     ComponentInstance itself;
  91. {
  92.     ComponentInstanceObject *it;
  93.     if (itself == NULL) {
  94.                         PyErr_SetString(Cm_Error,"NULL ComponentInstance");
  95.                         return NULL;
  96.                     }
  97.     it = PyObject_NEW(ComponentInstanceObject, &ComponentInstance_Type);
  98.     if (it == NULL) return NULL;
  99.     it->ob_itself = itself;
  100.     return (PyObject *)it;
  101. }
  102. CmpInstObj_Convert(v, p_itself)
  103.     PyObject *v;
  104.     ComponentInstance *p_itself;
  105. {
  106.     if (!CmpInstObj_Check(v))
  107.     {
  108.         PyErr_SetString(PyExc_TypeError, "ComponentInstance required");
  109.         return 0;
  110.     }
  111.     *p_itself = ((ComponentInstanceObject *)v)->ob_itself;
  112.     return 1;
  113. }
  114.  
  115. static void CmpInstObj_dealloc(self)
  116.     ComponentInstanceObject *self;
  117. {
  118.     /* Cleanup of self->ob_itself goes here */
  119.     PyMem_DEL(self);
  120. }
  121.  
  122. static PyObject *CmpInstObj_CloseComponent(_self, _args)
  123.     ComponentInstanceObject *_self;
  124.     PyObject *_args;
  125. {
  126.     PyObject *_res = NULL;
  127.     OSErr _err;
  128.     if (!PyArg_ParseTuple(_args, ""))
  129.         return NULL;
  130.     _err = CloseComponent(_self->ob_itself);
  131.     if (_err != noErr) return PyMac_Error(_err);
  132.     Py_INCREF(Py_None);
  133.     _res = Py_None;
  134.     return _res;
  135. }
  136.  
  137. static PyObject *CmpInstObj_GetComponentInstanceError(_self, _args)
  138.     ComponentInstanceObject *_self;
  139.     PyObject *_args;
  140. {
  141.     PyObject *_res = NULL;
  142.     OSErr _err;
  143.     if (!PyArg_ParseTuple(_args, ""))
  144.         return NULL;
  145.     _err = GetComponentInstanceError(_self->ob_itself);
  146.     if (_err != noErr) return PyMac_Error(_err);
  147.     Py_INCREF(Py_None);
  148.     _res = Py_None;
  149.     return _res;
  150. }
  151.  
  152. static PyObject *CmpInstObj_ComponentFunctionImplemented(_self, _args)
  153.     ComponentInstanceObject *_self;
  154.     PyObject *_args;
  155. {
  156.     PyObject *_res = NULL;
  157.     long _rv;
  158.     short ftnNumber;
  159.     if (!PyArg_ParseTuple(_args, "h",
  160.                           &ftnNumber))
  161.         return NULL;
  162.     _rv = ComponentFunctionImplemented(_self->ob_itself,
  163.                                        ftnNumber);
  164.     _res = Py_BuildValue("l",
  165.                          _rv);
  166.     return _res;
  167. }
  168.  
  169. static PyObject *CmpInstObj_GetComponentVersion(_self, _args)
  170.     ComponentInstanceObject *_self;
  171.     PyObject *_args;
  172. {
  173.     PyObject *_res = NULL;
  174.     long _rv;
  175.     if (!PyArg_ParseTuple(_args, ""))
  176.         return NULL;
  177.     _rv = GetComponentVersion(_self->ob_itself);
  178.     _res = Py_BuildValue("l",
  179.                          _rv);
  180.     return _res;
  181. }
  182.  
  183. static PyObject *CmpInstObj_ComponentSetTarget(_self, _args)
  184.     ComponentInstanceObject *_self;
  185.     PyObject *_args;
  186. {
  187.     PyObject *_res = NULL;
  188.     long _rv;
  189.     ComponentInstance target;
  190.     if (!PyArg_ParseTuple(_args, "O&",
  191.                           CmpInstObj_Convert, &target))
  192.         return NULL;
  193.     _rv = ComponentSetTarget(_self->ob_itself,
  194.                              target);
  195.     _res = Py_BuildValue("l",
  196.                          _rv);
  197.     return _res;
  198. }
  199.  
  200. static PyObject *CmpInstObj_SetComponentInstanceError(_self, _args)
  201.     ComponentInstanceObject *_self;
  202.     PyObject *_args;
  203. {
  204.     PyObject *_res = NULL;
  205.     OSErr theError;
  206.     if (!PyArg_ParseTuple(_args, "h",
  207.                           &theError))
  208.         return NULL;
  209.     SetComponentInstanceError(_self->ob_itself,
  210.                               theError);
  211.     Py_INCREF(Py_None);
  212.     _res = Py_None;
  213.     return _res;
  214. }
  215.  
  216. static PyObject *CmpInstObj_GetComponentInstanceStorage(_self, _args)
  217.     ComponentInstanceObject *_self;
  218.     PyObject *_args;
  219. {
  220.     PyObject *_res = NULL;
  221.     Handle _rv;
  222.     if (!PyArg_ParseTuple(_args, ""))
  223.         return NULL;
  224.     _rv = GetComponentInstanceStorage(_self->ob_itself);
  225.     _res = Py_BuildValue("O&",
  226.                          ResObj_New, _rv);
  227.     return _res;
  228. }
  229.  
  230. static PyObject *CmpInstObj_SetComponentInstanceStorage(_self, _args)
  231.     ComponentInstanceObject *_self;
  232.     PyObject *_args;
  233. {
  234.     PyObject *_res = NULL;
  235.     Handle theStorage;
  236.     if (!PyArg_ParseTuple(_args, "O&",
  237.                           ResObj_Convert, &theStorage))
  238.         return NULL;
  239.     SetComponentInstanceStorage(_self->ob_itself,
  240.                                 theStorage);
  241.     Py_INCREF(Py_None);
  242.     _res = Py_None;
  243.     return _res;
  244. }
  245.  
  246. static PyObject *CmpInstObj_GetComponentInstanceA5(_self, _args)
  247.     ComponentInstanceObject *_self;
  248.     PyObject *_args;
  249. {
  250.     PyObject *_res = NULL;
  251.     long _rv;
  252.     if (!PyArg_ParseTuple(_args, ""))
  253.         return NULL;
  254.     _rv = GetComponentInstanceA5(_self->ob_itself);
  255.     _res = Py_BuildValue("l",
  256.                          _rv);
  257.     return _res;
  258. }
  259.  
  260. static PyObject *CmpInstObj_SetComponentInstanceA5(_self, _args)
  261.     ComponentInstanceObject *_self;
  262.     PyObject *_args;
  263. {
  264.     PyObject *_res = NULL;
  265.     long theA5;
  266.     if (!PyArg_ParseTuple(_args, "l",
  267.                           &theA5))
  268.         return NULL;
  269.     SetComponentInstanceA5(_self->ob_itself,
  270.                            theA5);
  271.     Py_INCREF(Py_None);
  272.     _res = Py_None;
  273.     return _res;
  274. }
  275.  
  276. static PyMethodDef CmpInstObj_methods[] = {
  277.     {"CloseComponent", (PyCFunction)CmpInstObj_CloseComponent, 1,
  278.      "() -> None"},
  279.     {"GetComponentInstanceError", (PyCFunction)CmpInstObj_GetComponentInstanceError, 1,
  280.      "() -> None"},
  281.     {"ComponentFunctionImplemented", (PyCFunction)CmpInstObj_ComponentFunctionImplemented, 1,
  282.      "(short ftnNumber) -> (long _rv)"},
  283.     {"GetComponentVersion", (PyCFunction)CmpInstObj_GetComponentVersion, 1,
  284.      "() -> (long _rv)"},
  285.     {"ComponentSetTarget", (PyCFunction)CmpInstObj_ComponentSetTarget, 1,
  286.      "(ComponentInstance target) -> (long _rv)"},
  287.     {"SetComponentInstanceError", (PyCFunction)CmpInstObj_SetComponentInstanceError, 1,
  288.      "(OSErr theError) -> None"},
  289.     {"GetComponentInstanceStorage", (PyCFunction)CmpInstObj_GetComponentInstanceStorage, 1,
  290.      "() -> (Handle _rv)"},
  291.     {"SetComponentInstanceStorage", (PyCFunction)CmpInstObj_SetComponentInstanceStorage, 1,
  292.      "(Handle theStorage) -> None"},
  293.     {"GetComponentInstanceA5", (PyCFunction)CmpInstObj_GetComponentInstanceA5, 1,
  294.      "() -> (long _rv)"},
  295.     {"SetComponentInstanceA5", (PyCFunction)CmpInstObj_SetComponentInstanceA5, 1,
  296.      "(long theA5) -> None"},
  297.     {NULL, NULL, 0}
  298. };
  299.  
  300. PyMethodChain CmpInstObj_chain = { CmpInstObj_methods, NULL };
  301.  
  302. static PyObject *CmpInstObj_getattr(self, name)
  303.     ComponentInstanceObject *self;
  304.     char *name;
  305. {
  306.     return Py_FindMethodInChain(&CmpInstObj_chain, (PyObject *)self, name);
  307. }
  308.  
  309. #define CmpInstObj_setattr NULL
  310.  
  311. PyTypeObject ComponentInstance_Type = {
  312.     PyObject_HEAD_INIT(&PyType_Type)
  313.     0, /*ob_size*/
  314.     "ComponentInstance", /*tp_name*/
  315.     sizeof(ComponentInstanceObject), /*tp_basicsize*/
  316.     0, /*tp_itemsize*/
  317.     /* methods */
  318.     (destructor) CmpInstObj_dealloc, /*tp_dealloc*/
  319.     0, /*tp_print*/
  320.     (getattrfunc) CmpInstObj_getattr, /*tp_getattr*/
  321.     (setattrfunc) CmpInstObj_setattr, /*tp_setattr*/
  322. };
  323.  
  324. /* --------------- End object type ComponentInstance ---------------- */
  325.  
  326.  
  327. /* --------------------- Object type Component ---------------------- */
  328.  
  329. PyTypeObject Component_Type;
  330.  
  331. #define CmpObj_Check(x) ((x)->ob_type == &Component_Type)
  332.  
  333. typedef struct ComponentObject {
  334.     PyObject_HEAD
  335.     Component ob_itself;
  336. } ComponentObject;
  337.  
  338. PyObject *CmpObj_New(itself)
  339.     Component itself;
  340. {
  341.     ComponentObject *it;
  342.     if (itself == NULL) {
  343.                         /* XXXX Or should we return None? */
  344.                         PyErr_SetString(Cm_Error,"No such component");
  345.                         return NULL;
  346.                     }
  347.     it = PyObject_NEW(ComponentObject, &Component_Type);
  348.     if (it == NULL) return NULL;
  349.     it->ob_itself = itself;
  350.     return (PyObject *)it;
  351. }
  352. CmpObj_Convert(v, p_itself)
  353.     PyObject *v;
  354.     Component *p_itself;
  355. {
  356.     if ( v == Py_None ) {
  357.                         *p_itself = 0;
  358.                         return 1;
  359.             }
  360.     if (!CmpObj_Check(v))
  361.     {
  362.         PyErr_SetString(PyExc_TypeError, "Component required");
  363.         return 0;
  364.     }
  365.     *p_itself = ((ComponentObject *)v)->ob_itself;
  366.     return 1;
  367. }
  368.  
  369. static void CmpObj_dealloc(self)
  370.     ComponentObject *self;
  371. {
  372.     /* Cleanup of self->ob_itself goes here */
  373.     PyMem_DEL(self);
  374. }
  375.  
  376. static PyObject *CmpObj_UnregisterComponent(_self, _args)
  377.     ComponentObject *_self;
  378.     PyObject *_args;
  379. {
  380.     PyObject *_res = NULL;
  381.     OSErr _err;
  382.     if (!PyArg_ParseTuple(_args, ""))
  383.         return NULL;
  384.     _err = UnregisterComponent(_self->ob_itself);
  385.     if (_err != noErr) return PyMac_Error(_err);
  386.     Py_INCREF(Py_None);
  387.     _res = Py_None;
  388.     return _res;
  389. }
  390.  
  391. static PyObject *CmpObj_GetComponentInfo(_self, _args)
  392.     ComponentObject *_self;
  393.     PyObject *_args;
  394. {
  395.     PyObject *_res = NULL;
  396.     OSErr _err;
  397.     ComponentDescription cd;
  398.     Handle componentName;
  399.     Handle componentInfo;
  400.     Handle componentIcon;
  401.     if (!PyArg_ParseTuple(_args, "O&O&O&",
  402.                           ResObj_Convert, &componentName,
  403.                           ResObj_Convert, &componentInfo,
  404.                           ResObj_Convert, &componentIcon))
  405.         return NULL;
  406.     _err = GetComponentInfo(_self->ob_itself,
  407.                             &cd,
  408.                             componentName,
  409.                             componentInfo,
  410.                             componentIcon);
  411.     if (_err != noErr) return PyMac_Error(_err);
  412.     _res = Py_BuildValue("O&",
  413.                          CmpDesc_New, &cd);
  414.     return _res;
  415. }
  416.  
  417. static PyObject *CmpObj_OpenComponent(_self, _args)
  418.     ComponentObject *_self;
  419.     PyObject *_args;
  420. {
  421.     PyObject *_res = NULL;
  422.     ComponentInstance _rv;
  423.     if (!PyArg_ParseTuple(_args, ""))
  424.         return NULL;
  425.     _rv = OpenComponent(_self->ob_itself);
  426.     _res = Py_BuildValue("O&",
  427.                          CmpInstObj_New, _rv);
  428.     return _res;
  429. }
  430.  
  431. static PyObject *CmpObj_GetComponentRefcon(_self, _args)
  432.     ComponentObject *_self;
  433.     PyObject *_args;
  434. {
  435.     PyObject *_res = NULL;
  436.     long _rv;
  437.     if (!PyArg_ParseTuple(_args, ""))
  438.         return NULL;
  439.     _rv = GetComponentRefcon(_self->ob_itself);
  440.     _res = Py_BuildValue("l",
  441.                          _rv);
  442.     return _res;
  443. }
  444.  
  445. static PyObject *CmpObj_SetComponentRefcon(_self, _args)
  446.     ComponentObject *_self;
  447.     PyObject *_args;
  448. {
  449.     PyObject *_res = NULL;
  450.     long theRefcon;
  451.     if (!PyArg_ParseTuple(_args, "l",
  452.                           &theRefcon))
  453.         return NULL;
  454.     SetComponentRefcon(_self->ob_itself,
  455.                        theRefcon);
  456.     Py_INCREF(Py_None);
  457.     _res = Py_None;
  458.     return _res;
  459. }
  460.  
  461. static PyObject *CmpObj_OpenComponentResFile(_self, _args)
  462.     ComponentObject *_self;
  463.     PyObject *_args;
  464. {
  465.     PyObject *_res = NULL;
  466.     short _rv;
  467.     if (!PyArg_ParseTuple(_args, ""))
  468.         return NULL;
  469.     _rv = OpenComponentResFile(_self->ob_itself);
  470.     _res = Py_BuildValue("h",
  471.                          _rv);
  472.     return _res;
  473. }
  474.  
  475. static PyObject *CmpObj_CountComponentInstances(_self, _args)
  476.     ComponentObject *_self;
  477.     PyObject *_args;
  478. {
  479.     PyObject *_res = NULL;
  480.     long _rv;
  481.     if (!PyArg_ParseTuple(_args, ""))
  482.         return NULL;
  483.     _rv = CountComponentInstances(_self->ob_itself);
  484.     _res = Py_BuildValue("l",
  485.                          _rv);
  486.     return _res;
  487. }
  488.  
  489. static PyObject *CmpObj_SetDefaultComponent(_self, _args)
  490.     ComponentObject *_self;
  491.     PyObject *_args;
  492. {
  493.     PyObject *_res = NULL;
  494.     OSErr _err;
  495.     short flags;
  496.     if (!PyArg_ParseTuple(_args, "h",
  497.                           &flags))
  498.         return NULL;
  499.     _err = SetDefaultComponent(_self->ob_itself,
  500.                                flags);
  501.     if (_err != noErr) return PyMac_Error(_err);
  502.     Py_INCREF(Py_None);
  503.     _res = Py_None;
  504.     return _res;
  505. }
  506.  
  507. static PyObject *CmpObj_CaptureComponent(_self, _args)
  508.     ComponentObject *_self;
  509.     PyObject *_args;
  510. {
  511.     PyObject *_res = NULL;
  512.     Component _rv;
  513.     Component capturingComponent;
  514.     if (!PyArg_ParseTuple(_args, "O&",
  515.                           CmpObj_Convert, &capturingComponent))
  516.         return NULL;
  517.     _rv = CaptureComponent(_self->ob_itself,
  518.                            capturingComponent);
  519.     _res = Py_BuildValue("O&",
  520.                          CmpObj_New, _rv);
  521.     return _res;
  522. }
  523.  
  524. static PyObject *CmpObj_UncaptureComponent(_self, _args)
  525.     ComponentObject *_self;
  526.     PyObject *_args;
  527. {
  528.     PyObject *_res = NULL;
  529.     OSErr _err;
  530.     if (!PyArg_ParseTuple(_args, ""))
  531.         return NULL;
  532.     _err = UncaptureComponent(_self->ob_itself);
  533.     if (_err != noErr) return PyMac_Error(_err);
  534.     Py_INCREF(Py_None);
  535.     _res = Py_None;
  536.     return _res;
  537. }
  538.  
  539. static PyObject *CmpObj_GetComponentIconSuite(_self, _args)
  540.     ComponentObject *_self;
  541.     PyObject *_args;
  542. {
  543.     PyObject *_res = NULL;
  544.     OSErr _err;
  545.     Handle iconSuite;
  546.     if (!PyArg_ParseTuple(_args, ""))
  547.         return NULL;
  548.     _err = GetComponentIconSuite(_self->ob_itself,
  549.                                  &iconSuite);
  550.     if (_err != noErr) return PyMac_Error(_err);
  551.     _res = Py_BuildValue("O&",
  552.                          ResObj_New, iconSuite);
  553.     return _res;
  554. }
  555.  
  556. static PyMethodDef CmpObj_methods[] = {
  557.     {"UnregisterComponent", (PyCFunction)CmpObj_UnregisterComponent, 1,
  558.      "() -> None"},
  559.     {"GetComponentInfo", (PyCFunction)CmpObj_GetComponentInfo, 1,
  560.      "(Handle componentName, Handle componentInfo, Handle componentIcon) -> (ComponentDescription cd)"},
  561.     {"OpenComponent", (PyCFunction)CmpObj_OpenComponent, 1,
  562.      "() -> (ComponentInstance _rv)"},
  563.     {"GetComponentRefcon", (PyCFunction)CmpObj_GetComponentRefcon, 1,
  564.      "() -> (long _rv)"},
  565.     {"SetComponentRefcon", (PyCFunction)CmpObj_SetComponentRefcon, 1,
  566.      "(long theRefcon) -> None"},
  567.     {"OpenComponentResFile", (PyCFunction)CmpObj_OpenComponentResFile, 1,
  568.      "() -> (short _rv)"},
  569.     {"CountComponentInstances", (PyCFunction)CmpObj_CountComponentInstances, 1,
  570.      "() -> (long _rv)"},
  571.     {"SetDefaultComponent", (PyCFunction)CmpObj_SetDefaultComponent, 1,
  572.      "(short flags) -> None"},
  573.     {"CaptureComponent", (PyCFunction)CmpObj_CaptureComponent, 1,
  574.      "(Component capturingComponent) -> (Component _rv)"},
  575.     {"UncaptureComponent", (PyCFunction)CmpObj_UncaptureComponent, 1,
  576.      "() -> None"},
  577.     {"GetComponentIconSuite", (PyCFunction)CmpObj_GetComponentIconSuite, 1,
  578.      "() -> (Handle iconSuite)"},
  579.     {NULL, NULL, 0}
  580. };
  581.  
  582. PyMethodChain CmpObj_chain = { CmpObj_methods, NULL };
  583.  
  584. static PyObject *CmpObj_getattr(self, name)
  585.     ComponentObject *self;
  586.     char *name;
  587. {
  588.     return Py_FindMethodInChain(&CmpObj_chain, (PyObject *)self, name);
  589. }
  590.  
  591. #define CmpObj_setattr NULL
  592.  
  593. PyTypeObject Component_Type = {
  594.     PyObject_HEAD_INIT(&PyType_Type)
  595.     0, /*ob_size*/
  596.     "Component", /*tp_name*/
  597.     sizeof(ComponentObject), /*tp_basicsize*/
  598.     0, /*tp_itemsize*/
  599.     /* methods */
  600.     (destructor) CmpObj_dealloc, /*tp_dealloc*/
  601.     0, /*tp_print*/
  602.     (getattrfunc) CmpObj_getattr, /*tp_getattr*/
  603.     (setattrfunc) CmpObj_setattr, /*tp_setattr*/
  604. };
  605.  
  606. /* ------------------- End object type Component -------------------- */
  607.  
  608.  
  609. static PyObject *Cm_RegisterComponentResource(_self, _args)
  610.     PyObject *_self;
  611.     PyObject *_args;
  612. {
  613.     PyObject *_res = NULL;
  614.     Component _rv;
  615.     ComponentResourceHandle tr;
  616.     short global;
  617.     if (!PyArg_ParseTuple(_args, "O&h",
  618.                           ResObj_Convert, &tr,
  619.                           &global))
  620.         return NULL;
  621.     _rv = RegisterComponentResource(tr,
  622.                                     global);
  623.     _res = Py_BuildValue("O&",
  624.                          CmpObj_New, _rv);
  625.     return _res;
  626. }
  627.  
  628. static PyObject *Cm_FindNextComponent(_self, _args)
  629.     PyObject *_self;
  630.     PyObject *_args;
  631. {
  632.     PyObject *_res = NULL;
  633.     Component _rv;
  634.     Component aComponent;
  635.     ComponentDescription looking;
  636.     if (!PyArg_ParseTuple(_args, "O&O&",
  637.                           CmpObj_Convert, &aComponent,
  638.                           CmpDesc_Convert, &looking))
  639.         return NULL;
  640.     _rv = FindNextComponent(aComponent,
  641.                             &looking);
  642.     _res = Py_BuildValue("O&",
  643.                          CmpObj_New, _rv);
  644.     return _res;
  645. }
  646.  
  647. static PyObject *Cm_CountComponents(_self, _args)
  648.     PyObject *_self;
  649.     PyObject *_args;
  650. {
  651.     PyObject *_res = NULL;
  652.     long _rv;
  653.     ComponentDescription looking;
  654.     if (!PyArg_ParseTuple(_args, "O&",
  655.                           CmpDesc_Convert, &looking))
  656.         return NULL;
  657.     _rv = CountComponents(&looking);
  658.     _res = Py_BuildValue("l",
  659.                          _rv);
  660.     return _res;
  661. }
  662.  
  663. static PyObject *Cm_GetComponentListModSeed(_self, _args)
  664.     PyObject *_self;
  665.     PyObject *_args;
  666. {
  667.     PyObject *_res = NULL;
  668.     long _rv;
  669.     if (!PyArg_ParseTuple(_args, ""))
  670.         return NULL;
  671.     _rv = GetComponentListModSeed();
  672.     _res = Py_BuildValue("l",
  673.                          _rv);
  674.     return _res;
  675. }
  676.  
  677. static PyObject *Cm_CloseComponentResFile(_self, _args)
  678.     PyObject *_self;
  679.     PyObject *_args;
  680. {
  681.     PyObject *_res = NULL;
  682.     OSErr _err;
  683.     short refnum;
  684.     if (!PyArg_ParseTuple(_args, "h",
  685.                           &refnum))
  686.         return NULL;
  687.     _err = CloseComponentResFile(refnum);
  688.     if (_err != noErr) return PyMac_Error(_err);
  689.     Py_INCREF(Py_None);
  690.     _res = Py_None;
  691.     return _res;
  692. }
  693.  
  694. static PyObject *Cm_OpenDefaultComponent(_self, _args)
  695.     PyObject *_self;
  696.     PyObject *_args;
  697. {
  698.     PyObject *_res = NULL;
  699.     ComponentInstance _rv;
  700.     OSType componentType;
  701.     OSType componentSubType;
  702.     if (!PyArg_ParseTuple(_args, "O&O&",
  703.                           PyMac_GetOSType, &componentType,
  704.                           PyMac_GetOSType, &componentSubType))
  705.         return NULL;
  706.     _rv = OpenDefaultComponent(componentType,
  707.                                componentSubType);
  708.     _res = Py_BuildValue("O&",
  709.                          CmpInstObj_New, _rv);
  710.     return _res;
  711. }
  712.  
  713. static PyObject *Cm_RegisterComponentResourceFile(_self, _args)
  714.     PyObject *_self;
  715.     PyObject *_args;
  716. {
  717.     PyObject *_res = NULL;
  718.     long _rv;
  719.     short resRefNum;
  720.     short global;
  721.     if (!PyArg_ParseTuple(_args, "hh",
  722.                           &resRefNum,
  723.                           &global))
  724.         return NULL;
  725.     _rv = RegisterComponentResourceFile(resRefNum,
  726.                                         global);
  727.     _res = Py_BuildValue("l",
  728.                          _rv);
  729.     return _res;
  730. }
  731.  
  732. static PyMethodDef Cm_methods[] = {
  733.     {"RegisterComponentResource", (PyCFunction)Cm_RegisterComponentResource, 1,
  734.      "(ComponentResourceHandle tr, short global) -> (Component _rv)"},
  735.     {"FindNextComponent", (PyCFunction)Cm_FindNextComponent, 1,
  736.      "(Component aComponent, ComponentDescription looking) -> (Component _rv)"},
  737.     {"CountComponents", (PyCFunction)Cm_CountComponents, 1,
  738.      "(ComponentDescription looking) -> (long _rv)"},
  739.     {"GetComponentListModSeed", (PyCFunction)Cm_GetComponentListModSeed, 1,
  740.      "() -> (long _rv)"},
  741.     {"CloseComponentResFile", (PyCFunction)Cm_CloseComponentResFile, 1,
  742.      "(short refnum) -> None"},
  743.     {"OpenDefaultComponent", (PyCFunction)Cm_OpenDefaultComponent, 1,
  744.      "(OSType componentType, OSType componentSubType) -> (ComponentInstance _rv)"},
  745.     {"RegisterComponentResourceFile", (PyCFunction)Cm_RegisterComponentResourceFile, 1,
  746.      "(short resRefNum, short global) -> (long _rv)"},
  747.     {NULL, NULL, 0}
  748. };
  749.  
  750.  
  751.  
  752.  
  753. void initCm()
  754. {
  755.     PyObject *m;
  756.     PyObject *d;
  757.  
  758.  
  759.  
  760.  
  761.     m = Py_InitModule("Cm", Cm_methods);
  762.     d = PyModule_GetDict(m);
  763.     Cm_Error = PyMac_GetOSErrException();
  764.     if (Cm_Error == NULL ||
  765.         PyDict_SetItemString(d, "Error", Cm_Error) != 0)
  766.         Py_FatalError("can't initialize Cm.Error");
  767. }
  768.  
  769. /* ========================= End module Cm ========================== */
  770.  
  771.